package com.jilian.powerstation.http;

import com.jilian.powerstation.Constant;
import com.jilian.powerstation.utils.DataUtils;
import com.jilian.powerstation.utils.SPUtil;

import java.util.Calendar;

/**
 * "浪小白" 创建 2019/8/15.
 * 界面名称以及功能:
 */
public class SocketConfig {
    /********************命令标识【收到到数据的下表第三位数据 取数组下标是2的数据】*********************/
    /***车辆登入**/
    public static byte VEHICLE_ACCESS = 0x01;
    /***实时信息上报**/
    public static byte REAL_TIME = 0x02;
    /***心跳**/
    public static byte HEARTBEAT = 0x03;
    /***补发信息上报**/
    public static byte REPLACEMENT_INFORMATION = 0x04;
    /***车辆登出**/
    public static byte VEHICLE_LOGOUT = 0x05;
    /***终端校时**/
    public static byte TERMINAL_CORRECTION = 0x08;
    /***查询命令**/
    public static byte SEARCH = (byte) 0x80;
    /***设置命令**/
    public static byte SETTING = (byte) 0x81;
    /***车载终端控制**/
    public static byte VEHICLE_MOUNTED = (byte) 0x82;
    /***固件升级**/
    public static byte UPDATE = (byte) 0x83;

    /********************应答标识【收到到数据的下表第四位数据 取数组下标是3的数据】*********************/

    /***成功[接收到的信息正确]**/
    public static byte SUCCESS = 0x01;
    /***修改失败[设置未成功]**/
    public static byte ERROR = 0x02;
    /***VIN重复[VIN重复错误]**/
    public static byte VIN_ERROR = 0x03;
    /***命令[表示数据包为命令包，而非应答包]**/
    public static byte COMMAND = (byte) 0xFE;

    /********************发送命令*********************/

    /******数据核实正确，返回这条命令，否则设备会反复返回同样的数据******/
    public static byte[] settingVehicleAccess(byte[] send) {
        send[3] = SUCCESS;//车辆登入应答标识表示接受成功
        send[send.length - 1] = DataUtils.HexToByte(SocketUtils.getBCC(send));//重新校验GCC校验和并赋值,否则设备无法通过该组数据
        byte[] contentByte = new byte[send.length];
        System.arraycopy(send, 0, contentByte, 0, send.length);
        return contentByte;
    }

    /**
     * 获取基础设置信息 暂未完善
     * @return
     */
    public static byte[] getSetting() {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[39];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x80;
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x0E;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x07;
        //具体参数
        contentByte[31]=(byte)0xB6;
        contentByte[32]=(byte)0xD1;
        contentByte[33]=(byte)0x8C;
        contentByte[34]=(byte)0x98;
        contentByte[35]=(byte)0xAA;
        contentByte[36]=(byte)0xA9;
        contentByte[37]=(byte)0xA8;
        //校验码
        contentByte[38]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }
    //232380FE121212121212121212121212121212121201--0E00--138012121212-07--B6D18C98AAA9A8

    /**
     *
     * @param B6 MPPT模式
     * @param D1 馈电功率限值
     * @param baC 市电充电功率限值
     * @param jiuba EPS功能使能
     * @param AA 自发自用截止SOC
     * @param A9 错峰用电截止SOC
     * @param A8 电池SOC下限保护
     * @return
     */
    public static byte[] baseSetting(int B6,int D1,int baC,int jiuba,int AA,int A9,int A8) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[53];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x1c;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x07;

        //具体参数
        contentByte[31]=(byte)0xB6;
        //10进制转换成 四位数16进制字符串
        String B6str = DataUtils.hexInt(B6);
        //后两位为第一个字节
        String oneB6 = B6str.substring(2);
        //前两位为第二个自己
        String twoB6 = B6str.substring(0,2);
        //拼接起来
        contentByte[32]=(byte) DataUtils.HexToByte(oneB6);  //  hexInt  10进制 转换成 4位16进制
        contentByte[33]=(byte)DataUtils.HexToByte(twoB6);

        contentByte[34]=(byte)0xD1;
        //10进制转换成 四位数16进制字符串
        String D1str = DataUtils.hexInt(D1);
        //后两位为第一个字节
        String oneD1 = D1str.substring(2);
        //前两位为第二个自己
        String twoD1 = D1str.substring(0,2);
        contentByte[35]=DataUtils.HexToByte(oneD1);
        contentByte[36]=DataUtils.HexToByte(twoD1);





        contentByte[37]=(byte)0x8C;
        //10进制转换成 四位数16进制字符串
        String baCstr = DataUtils.hexInt(baC);
        //后两位为第一个字节
        String onebaC = baCstr.substring(2);
        //前两位为第二个自己
        String twobaC = baCstr.substring(0,2);
        contentByte[38]=DataUtils.HexToByte(onebaC);
        contentByte[39]=DataUtils.HexToByte(twobaC);


        contentByte[40]=(byte)0x98;
        //10进制转换成 四位数16进制字符串
        String jiubastr = DataUtils.hexInt(jiuba);
        //后两位为第一个字节
        String onejiuba = jiubastr.substring(2);
        //前两位为第二个自己
        String twobjiuba = jiubastr.substring(0,2);
        contentByte[41]=DataUtils.HexToByte(onejiuba);
        contentByte[42]=DataUtils.HexToByte(twobjiuba);


        contentByte[43]=(byte)0xAA;
        //10进制转换成 四位数16进制字符串
        String AAstr = DataUtils.hexInt(AA);
        //后两位为第一个字节
        String oneAA = AAstr.substring(2);
        //前两位为第二个自己
        String twobAA = AAstr.substring(0,2);
        contentByte[44]=DataUtils.HexToByte(oneAA);
        contentByte[45]=DataUtils.HexToByte(twobAA);




        contentByte[46]=(byte)0xA9;
        //10进制转换成 四位数16进制字符串
        String A9str = DataUtils.hexInt(A9);
        //后两位为第一个字节
        String oneA9 = A9str.substring(2);
        //前两位为第二个自己
        String twoA9 = A9str.substring(0,2);
        contentByte[47]=DataUtils.HexToByte(oneA9);
        contentByte[48]=DataUtils.HexToByte(twoA9);


        contentByte[49]=(byte)0xA8;
        //10进制转换成 四位数16进制字符串
        String A8str = DataUtils.hexInt(A8);
        //后两位为第一个字节
        String oneA8 = A8str.substring(2);
        //前两位为第二个自己
        String twoA8 = A8str.substring(0,2);
        contentByte[50]=DataUtils.HexToByte(oneA8);
        contentByte[51]=DataUtils.HexToByte(twoA8);

        //校验码
        contentByte[52]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }





    /**
     * 获取高级设置信息
     * @return
     */
    public static byte[] getAdvanceSetting() {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+15+1
        byte[] contentByte = new byte[47];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x80;
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  22位 长度相反
        contentByte[22] = (byte)0x16;
        contentByte[23] = (byte)0x00;

        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节    15个参数
        contentByte[30]=(byte)0x0f;
        //具体参数
        contentByte[31]=(byte)0xA1;//电池最大充电电压（DCDC） 1V
        contentByte[32]=(byte)0xA2;//电池最大充电电流（DCDC） 1A
        contentByte[33]=(byte)0xA4;//电池最大放电电流（DCDC）1A
        contentByte[34]=(byte)0xB1;//数据上传间隔 1MS
        contentByte[35]=(byte)0xD2;//安规标准0:澳洲 1：新西兰 2：德国 3：预留
        contentByte[36]=(byte)0xBE;//电网电压响应模式  0: 电压功率响应模式 1: 电压无功响应模式 2: 固定功率因数 无功响应模式 3: 特征功率因数曲线响应模式
        contentByte[37]=(byte)0xBB;//并网功率因素 0.01
        contentByte[38]=(byte)0xCA;//并网充电功率上升梯度 0.01%
        contentByte[39]=(byte)0xCF;//并网放电功率上升梯度 0.01%
        contentByte[40]=(byte)0xCB;//梯度调控过频点  0.01HZ
        contentByte[41]=(byte)0xCC;//梯度调控欠频点  0.01HZ
        contentByte[42]=(byte)0xC7;//电压响应参考值V2 0.1V
        contentByte[43]=(byte)0xC8;//电压响应参考值V3 0.1V
        contentByte[44]=(byte)0xC9;//电压响应参考值V4 0.1V
        contentByte[45]=(byte)0xCD;//电网电压10min平均最大值 0.1V
        //校验码
        contentByte[46]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }


    /**
     *
     * @param a
     * @param b
     * @param c
     * @param d
     * @param e
     * @param f
     * @param g
     * @param h
     * @param i
     * @param j
     * @param k
     * @param l
     * @param m
     * @param n
     * @param o
     * @return
     */
    public static byte[] advanceSetting(int a,int b,int c,int d,int e,int g,int h,int i,int j,int k,int l,int m,int n,int o) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[74];//+24
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int z = 0; z < s.length; z++) {
            contentByte[4 + z] = DataUtils.HexToByte(s[z]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x31;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x0e;

        //具体参数
        contentByte[31]=(byte)0xA1;
        //10进制转换成 四位数16进制字符串
        String astr = DataUtils.hexInt(a);
        //后两位为第一个字节
        String onea = astr.substring(2);
        //前两位为第二个自己
        String twoa = astr.substring(0,2);
        //拼接起来
        contentByte[32]=(byte) DataUtils.HexToByte(onea);  //  hexInt  10进制 转换成 4位16进制
        contentByte[33]=(byte)DataUtils.HexToByte(twoa);


        contentByte[34]=(byte)0xA2;
        //10进制转换成 四位数16进制字符串
        String bstr = DataUtils.hexInt(b);
        //后两位为第一个字节
        String oneb = bstr.substring(2);
        //前两位为第二个自己
        String twob = bstr.substring(0,2);
        contentByte[35]=DataUtils.HexToByte(oneb);
        contentByte[36]=DataUtils.HexToByte(twob);





        contentByte[37]=(byte)0xA4;
        //10进制转换成 四位数16进制字符串
        String cstr = DataUtils.hexInt(c);
        //后两位为第一个字节
        String onec = cstr.substring(2);
        //前两位为第二个自己
        String twoc = cstr.substring(0,2);
        contentByte[38]=DataUtils.HexToByte(onec);
        contentByte[39]=DataUtils.HexToByte(twoc);


        contentByte[40]=(byte)0xB1;
        //10进制转换成 四位数16进制字符串
        String dstr = DataUtils.hexInt(d);
        //后两位为第一个字节
        String oned = dstr.substring(2);
        //前两位为第二个自己
        String twod = dstr.substring(0,2);
        contentByte[41]=DataUtils.HexToByte(oned);
        contentByte[42]=DataUtils.HexToByte(twod);


        contentByte[43]=(byte)0xD2;
        //10进制转换成 四位数16进制字符串
        String estr = DataUtils.hexInt(e);
        //后两位为第一个字节
        String onee = estr.substring(2);
        //前两位为第二个自己
        String twoe = estr.substring(0,2);
        contentByte[44]=DataUtils.HexToByte(onee);
        contentByte[45]=DataUtils.HexToByte(twoe);




//        contentByte[46]=(byte)0xBE;
//        //10进制转换成 四位数16进制字符串
//        String fstr = DataUtils.hexInt(f);
//        //后两位为第一个字节
//        String onef = fstr.substring(2);
//        //前两位为第二个自己
//        String twof = fstr.substring(0,2);
//        contentByte[47]=DataUtils.HexToByte(onef);
//        contentByte[48]=DataUtils.HexToByte(twof);


        contentByte[46]=(byte)0xBB;
        //10进制转换成 四位数16进制字符串
        String gstr = DataUtils.hexInt(g);
        //后两位为第一个字节
        String oneg = gstr.substring(2);
        //前两位为第二个自己
        String twog = gstr.substring(0,2);
        contentByte[47]=DataUtils.HexToByte(oneg);
        contentByte[48]=DataUtils.HexToByte(twog);


        contentByte[49]=(byte)0xCA;
        //10进制转换成 四位数16进制字符串
        String hstr = DataUtils.hexInt(h);
        //后两位为第一个字节
        String oneh = hstr.substring(2);
        //前两位为第二个自己
        String twoh = hstr.substring(0,2);
        contentByte[50]=DataUtils.HexToByte(oneh);
        contentByte[51]=DataUtils.HexToByte(twoh);


        contentByte[52]=(byte)0xCF;
        //10进制转换成 四位数16进制字符串
        String istr = DataUtils.hexInt(i);
        //后两位为第一个字节
        String onei = istr.substring(2);
        //前两位为第二个自己
        String twoi = istr.substring(0,2);
        contentByte[53]=DataUtils.HexToByte(onei);
        contentByte[54]=DataUtils.HexToByte(twoi);


        contentByte[55]=(byte)0xCB;
        //10进制转换成 四位数16进制字符串
        String jstr = DataUtils.hexInt(j);
        //后两位为第一个字节
        String onej = jstr.substring(2);
        //前两位为第二个自己
        String twoj = jstr.substring(0,2);
        contentByte[56]=DataUtils.HexToByte(onej);
        contentByte[57]=DataUtils.HexToByte(twoj);



        contentByte[58]=(byte)0xCC;
        //10进制转换成 四位数16进制字符串
        String kstr = DataUtils.hexInt(k);
        //后两位为第一个字节
        String onek = kstr.substring(2);
        //前两位为第二个自己
        String twok = kstr.substring(0,2);
        contentByte[59]=DataUtils.HexToByte(onek);
        contentByte[60]=DataUtils.HexToByte(twok);


        contentByte[61]=(byte)0xC7;
        //10进制转换成 四位数16进制字符串
        String lstr = DataUtils.hexInt(l);
        //后两位为第一个字节
        String onel = lstr.substring(2);
        //前两位为第二个自己
        String twol = lstr.substring(0,2);
        contentByte[62]=DataUtils.HexToByte(onel);
        contentByte[63]=DataUtils.HexToByte(twol);


        contentByte[64]=(byte)0xC8;
        //10进制转换成 四位数16进制字符串
        String mstr = DataUtils.hexInt(m);
        //后两位为第一个字节
        String onem = mstr.substring(2);
        //前两位为第二个自己
        String twom = mstr.substring(0,2);
        contentByte[65]=DataUtils.HexToByte(onem);
        contentByte[66]=DataUtils.HexToByte(twom);


        contentByte[67]=(byte)0xC9;
        //10进制转换成 四位数16进制字符串
        String nstr = DataUtils.hexInt(n);
        //后两位为第一个字节
        String onen = nstr.substring(2);
        //前两位为第二个自己
        String twon = nstr.substring(0,2);
        contentByte[68]=DataUtils.HexToByte(onen);
        contentByte[69]=DataUtils.HexToByte(twon);


        contentByte[70]=(byte)0xCD;
        //10进制转换成 四位数16进制字符串
        String ostr = DataUtils.hexInt(o);
        //后两位为第一个字节
        String oneo = ostr.substring(2);
        //前两位为第二个自己
        String twoo = ostr.substring(0,2);
        contentByte[71]=DataUtils.HexToByte(oneo);
        contentByte[72]=DataUtils.HexToByte(twoo);



        //校验码
        contentByte[73]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }




    //


    /**
     * 获取手动操作设置信息
     * @return
     */
    public static byte[] getMannualSetting( ) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[36];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x80;
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  11位 长度相反
        contentByte[22] = (byte)0x0B;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x04;
        //具体参数
        contentByte[31]=(byte)0xBE;

        contentByte[32]=(byte)0x8C;
        contentByte[33]=(byte)0x8D;
        contentByte[34]=(byte)0x90;
        //校验码
        contentByte[35]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }


    /**手動操作設置
     * @param bac
     * @return
     */
    public static byte[] manualSetting8C(int bac) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[35];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  19位 长度相反
        contentByte[22] = (byte)0x0A;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节 12 3*4
        contentByte[30]=(byte)0x01;





        //具体参数
        contentByte[31]=(byte)0x8C;
        //10进制转换成 四位数16进制字符串
        String bacstr = DataUtils.hexInt(bac);
        //后两位为第一个字节
        String onebac = bacstr.substring(2);
        //前两位为第二个自己
        String twobac = bacstr.substring(0,2);
        //拼接起来
        contentByte[32]=(byte) DataUtils.HexToByte(onebac);  //  hexInt  10进制 转换成 4位16进制
        contentByte[33]=(byte)DataUtils.HexToByte(twobac);



        //校验码
        contentByte[34]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }
    public static byte[] manualSetting8D(int bad) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[35];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  19位 长度相反
        contentByte[22] = (byte)0x0A;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节 12 3*4
        contentByte[30]=(byte)0x01;


        contentByte[31]=(byte)0x8D;
        //10进制转换成 四位数16进制字符串
        String badstr = DataUtils.hexInt(bad);
        //后两位为第一个字节
        String onebad = badstr.substring(2);
        //前两位为第二个自己
        String twobad = badstr.substring(0,2);
        contentByte[32]=DataUtils.HexToByte(onebad);
        contentByte[33]=DataUtils.HexToByte(twobad);



        //校验码
        contentByte[34]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }

    public static byte[] manualSetting90(int  jiuling) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[35];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  13位 长度相反
        contentByte[22] = (byte)0x0A;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数
        contentByte[30]=(byte)0x01;



        contentByte[31]=(byte)0x90;
        //10进制转换成 四位数16进制字符串
        String jiulingstr = DataUtils.hexInt(jiuling);
        //后两位为第一个字节
        String onejiuling = jiulingstr.substring(2);
        //前两位为第二个自己
        String twojiuling= jiulingstr.substring(0,2);
        contentByte[32]=DataUtils.HexToByte(onejiuling);
        contentByte[33]=DataUtils.HexToByte(twojiuling);



        //校验码
        contentByte[34]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }


    /**
     * 获取电网电压响应设置
     * @return
     */
    public static byte[] getVoltResponseModeSetting( ) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[35];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x80;
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  10 位 长度相反
        contentByte[22] = (byte)0x0A;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x03;
        //具体参数
        contentByte[31]=(byte)0xBC;  //并网固定无功功率
        contentByte[32]=(byte)0xBB;//
        contentByte[33]=(byte)0xBE;  //并网固定无功功率

        //校验码
        contentByte[34]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }


    /**
     * 电网电压响应设置
     * @param BC
     * @param BE
     * @return
     */
    public static byte[] voltResponseModeSetting(int BC,int BB,int  BE) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[41];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  13位 长度相反
        contentByte[22] = (byte)0x10;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节 6 3*3
        contentByte[30]=(byte)0x03;

        //具体参数
        contentByte[31]=(byte)0xBC;
        //10进制转换成 四位数16进制字符串
//        String BCstr = DataUtils.hexInt(BC);
        String BCstr = Integer.toHexString(BC).toUpperCase();

        if(BCstr.length()>=4){
            BCstr = BCstr.substring(BCstr.length()-4);
        }
        else if(BCstr.length()==3){
            BCstr = "0"+BCstr;
        }
        else{
            BCstr = "00"+BCstr;
        }





        //后两位为第一个字节
        String oneBC = BCstr.substring(2);
        //前两位为第二个自己
        String twoBC = BCstr.substring(0,2);
        //拼接起来
        contentByte[32]=(byte) DataUtils.HexToByte(oneBC);  //  hexInt  10进制 转换成 4位16进制
        contentByte[33]=(byte)DataUtils.HexToByte(twoBC);




        //
        contentByte[34]=(byte)0xBB;
        //10进制转换成 四位数16进制字符串


        String BBstr = Integer.toHexString(BB).toUpperCase();

        if(BBstr.length()>=4){
            BBstr = BBstr.substring(BBstr.length()-4);
        }
        else if(BBstr.length()==3){
            BBstr = "0"+BBstr;
        }
        else{
            BBstr = "00"+BBstr;
        }

        BBstr = BBstr.substring(BBstr.length()-4);

        //后两位为第一个字节
        String oneBB  = BBstr.substring(2);
        //前两位为第二个自己
        String twoBB = BBstr.substring(0,2);
        contentByte[35]=DataUtils.HexToByte(oneBB);
        contentByte[36]=DataUtils.HexToByte(twoBB);



        contentByte[37]=(byte)0xBE;
        //10进制转换成 四位数16进制字符串
        String BDstr = DataUtils.hexInt(BE);
        //后两位为第一个字节
        String oneBD = BDstr.substring(2);
        //前两位为第二个自己
        String twoBD = BDstr.substring(0,2);
        contentByte[38]=DataUtils.HexToByte(oneBD);
        contentByte[39]=DataUtils.HexToByte(twoBD);




        //校验码
        contentByte[40]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }

    /**
     *
     * 电站设置查询
     * @return
     */
    public static byte[] getSiteSetting() {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[45];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x80;
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  20位 长度相反
        contentByte[22] = (byte)0x14;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x0D;
        //具体参数
        contentByte[31]=(byte)0xAA;

        contentByte[32]=(byte)0xAD;
        contentByte[33]=(byte)0xAB;
        contentByte[34]=(byte)0xAC;
        contentByte[35]=(byte)0xB0;
        contentByte[36]=(byte)0xAE;
        contentByte[37]=(byte)0xAF;

        contentByte[38]=(byte)0xD5;
        contentByte[39]=(byte)0xD3;

        contentByte[40]=(byte)0xD4;

        contentByte[41]=(byte)0xD8;
        contentByte[42]=(byte)0xD6;
        contentByte[43]=(byte)0xD7;


        //校验码
        contentByte[44]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }


    /**
     * 电站设置
     * @param AA
     * @param AD
     * @param AB
     * @param B0
     * @param AE
     * @param AF
     * @param D5
     * @param D3
     * @param D4
     * @param D8
     * @param D6
     * @param D7
     * @return
     */
    public static byte[] siteSetting(int AA,int AD,String AB,String AC,int B0,String AE,String AF,int D5,String D3,String D4,int D8,String D6,String D7) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[71];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x81;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x2E;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //参数总数 1个字节
        contentByte[30]=(byte)0x0D;

        //具体参数
        contentByte[31]=(byte)0xAA;
        //10进制转换成 四位数16进制字符串
        String AAstr = DataUtils.hexInt(AA);
        //后两位为第一个字节
        String oneAA = AAstr.substring(2);
        //前两位为第二个自己
        String twoAA = AAstr.substring(0,2);
        //拼接起来
        contentByte[32]=(byte) DataUtils.HexToByte(oneAA);  //  hexInt  10进制 转换成 4位16进制
        contentByte[33]=(byte)DataUtils.HexToByte(twoAA);



        /////////
        contentByte[34]=(byte)0xAD;
        //10进制转换成 四位数16进制字符串
        String ADstr = DataUtils.hexInt(AD);
        //后两位为第一个字节
        String oneAD = ADstr.substring(2);
        //前两位为第二个自己
        String twoAD = ADstr.substring(0,2);
        contentByte[35]=DataUtils.HexToByte(oneAD);
        contentByte[36]=DataUtils.HexToByte(twoAD);








        contentByte[37]=(byte)0xAB;

        //后两位为第一个字节
        String oneAB = DataUtils.hexInt(Integer.parseInt(AB.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoAB =DataUtils.hexInt(Integer.parseInt(AB.split(":")[1])).substring(2);
        contentByte[38]=DataUtils.HexToByte(oneAB);
        contentByte[39]=DataUtils.HexToByte(twoAB);



        contentByte[40]=(byte)0xAC;

        //后两位为第一个字节
        String oneAC = DataUtils.hexInt(Integer.parseInt(AC.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoAC =DataUtils.hexInt(Integer.parseInt(AC.split(":")[1])).substring(2);
        contentByte[41]=DataUtils.HexToByte(oneAC);
        contentByte[42]=DataUtils.HexToByte(twoAC);







        contentByte[43]=(byte)0xB0;
        //10进制转换成 四位数16进制字符串
        String B0str = DataUtils.hexInt(B0);
        //后两位为第一个字节
        String oneB0 = B0str.substring(2);
        //前两位为第二个自己
        String twoB0 = B0str.substring(0,2);
        contentByte[44]=DataUtils.HexToByte(oneB0);
        contentByte[45]=DataUtils.HexToByte(twoB0);




        contentByte[46]=(byte)0xAE;
        //10进制转换成 四位数16进制字符串
        //后两位为第一个字节
        String oneAE = DataUtils.hexInt(Integer.parseInt(AE.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoAE =  DataUtils.hexInt(Integer.parseInt(AE.split(":")[1])).substring(2);
        contentByte[47]=DataUtils.HexToByte(oneAE);
        contentByte[48]=DataUtils.HexToByte(twoAE);


        contentByte[49]=(byte)0xAF;
        //10进制转换成 四位数16进制字符串
        //后两位为第一个字节
        String oneAF =  DataUtils.hexInt(Integer.parseInt(AF.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoAF = DataUtils.hexInt(Integer.parseInt(AF.split(":")[1])).substring(2);
        contentByte[50]=DataUtils.HexToByte(oneAF);
        contentByte[51]=DataUtils.HexToByte(twoAF);





        contentByte[52]=(byte)0xD5;
        //10进制转换成 四位数16进制字符串
        String D5str = DataUtils.hexInt(D5);
        //后两位为第一个字节
        String oneD5 = D5str.substring(2);
        //前两位为第二个自己
        String twoD5= D5str.substring(0,2);
        contentByte[53]=DataUtils.HexToByte(oneD5);
        contentByte[54]=DataUtils.HexToByte(twoD5);




        contentByte[55]=(byte)0xD3;
        //10进制转换成 四位数16进制字符串
        //后两位为第一个字节
        String oneD3 = DataUtils.hexInt(Integer.parseInt(D3.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoD3 =  DataUtils.hexInt(Integer.parseInt(D3.split(":")[1])).substring(2);

        contentByte[56]=DataUtils.HexToByte(oneD3);
        contentByte[57]=DataUtils.HexToByte(twoD3);


        contentByte[58]=(byte)0xD4;
        //10进制转换成 四位数16进制字符串
        //后两位为第一个字节
        String oneD4 =  DataUtils.hexInt(Integer.parseInt(D4.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoD4 = DataUtils.hexInt(Integer.parseInt(D4.split(":")[1])).substring(2);

        contentByte[59]=DataUtils.HexToByte(oneD4);
        contentByte[60]=DataUtils.HexToByte(twoD4);




        contentByte[61]=(byte)0xD8;
        //10进制转换成 四位数16进制字符串
        String D8str = DataUtils.hexInt(D8);
        //后两位为第一个字节
        String oneD8 = D8str.substring(2);
        //前两位为第二个自己
        String twoD8= D8str.substring(0,2);
        contentByte[62]=DataUtils.HexToByte(oneD8);
        contentByte[63]=DataUtils.HexToByte(twoD8);






        contentByte[64]=(byte)0xD6;
        //10进制转换成 四位数16进制字符串
        //后两位为第一个字节
        String oneD6 = DataUtils.hexInt(Integer.parseInt(D6.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoD6 =  DataUtils.hexInt(Integer.parseInt(D6.split(":")[1])).substring(2);

        contentByte[65]=DataUtils.HexToByte(oneD6);
        contentByte[66]=DataUtils.HexToByte(twoD6);


        contentByte[67]=(byte)0xD7;
        //10进制转换成 四位数16进制字符串
        //后两位为第一个字节
        String oneD7 =  DataUtils.hexInt(Integer.parseInt(D7.split(":")[0])).substring(2);
        //前两位为第二个自己
        String twoD7 = DataUtils.hexInt(Integer.parseInt(D7.split(":")[1])).substring(2);

        contentByte[68]=DataUtils.HexToByte(oneD7);
        contentByte[69]=DataUtils.HexToByte(twoD7);




        //校验码
        contentByte[70]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }


    public static byte[] modeSetting(int type) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[33];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x82;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0xAA;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x08;
        contentByte[23] = (byte)0x00;

        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //命令ID
        contentByte[30]=(byte)0x82;
        //命令参数
        contentByte[31]=DataUtils.HexToByte(String.valueOf(type));
        //校验码
        contentByte[32]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }
    public static byte[] modeAdvanceSetting(int type) {
        // 39 等于 24固定+6时分秒+1参数总是+n总数+1
        //24+6+1+7+1
        byte[] contentByte = new byte[33];
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x82;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int i = 0; i < s.length; i++) {
            contentByte[4 + i] = DataUtils.HexToByte(s[i]);
        }
        //数据来源
        contentByte[21] = (byte) 0xAA;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x08;
        contentByte[23] = (byte)0x00;

        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));
        //命令ID
        contentByte[30]=(byte)0x81;
        //命令参数
        contentByte[31]=DataUtils.HexToByte(String.valueOf(type));
        //校验码
        contentByte[32]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }
    //发控制命令
    //选择国家
    public static byte[] selectCountry(int type) {

        byte[] contentByte = new byte[33];//+24
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x82;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int z = 0; z < s.length; z++) {
            contentByte[4 + z] = DataUtils.HexToByte(s[z]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x08;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));


        //命令ID
        contentByte[30]=(byte)0x85;
        //10进制转换成 四位数16进制字符串
        String ostr = DataUtils.hexInt(type);
        //命令参数
        contentByte[31]=DataUtils.HexToByte(ostr);

        //校验码
        contentByte[32]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }

    //发控制命令
    //恢复出厂
    public static byte[] resetSetting() {

        byte[] contentByte = new byte[32];//+24
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x82;//设置
        contentByte[3] = (byte) 0xFE;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int z = 0; z < s.length; z++) {
            contentByte[4 + z] = DataUtils.HexToByte(s[z]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  14位 长度相反
        contentByte[22] = (byte)0x07;
        contentByte[23] = (byte)0x00;


        //数据单元
        Calendar ca = Calendar.getInstance();
        //年 19年
        contentByte[24] = DataUtils.HexToByte(DataUtils.IntToHex(Integer.parseInt(String.valueOf(ca.get(Calendar.YEAR)).substring(2))));
        //月
        contentByte[25]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MONTH)+1));
        //日
        contentByte[26]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.DAY_OF_MONTH)));
        //时
        contentByte[27]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.HOUR_OF_DAY)));
        //分
        contentByte[28]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.MINUTE)));
        //秒
        contentByte[29]=DataUtils.HexToByte(DataUtils.IntToHex(ca.get(Calendar.SECOND)));


        //命令ID
        contentByte[30]=(byte)0x84;

        //校验码
        contentByte[31]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }

    public static String getBCC(byte[] data) {
        String ret = "";
        byte[] BCC = new byte[1];
        for (int i = 2; i < data.length - 1; i++) {
            BCC[0] = (byte) (BCC[0] ^ data[i]);
        }
        String hex = Integer.toHexString(BCC[0] & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        ret += hex.toUpperCase();
        return ret;
    }


    /**
     * 心跳
     * @param
     * @return
     */
    public static byte[] getHeart() {

        byte[] contentByte = new byte[25];//+24
        contentByte[0] = contentByte[1] = (byte) 0x23;
        contentByte[2] = (byte) 0x03;//
        contentByte[3] = (byte) 0x01;
        //设备识别码   17 位字节码构成
        String[] s = SPUtil.getData(Constant.SP_VALUE.SP, Constant.SP_VALUE.DEVICE_ID, String.class, "").replace("[","").replace("]","").split(",");
        for (int z = 0; z < s.length; z++) {
            contentByte[4 + z] = DataUtils.HexToByte(s[z]);
        }
        //数据来源
        contentByte[21] = (byte) 0x01;
        //数据单元长度 两个字节  0位 长度相反
        contentByte[22] = (byte)0x00;
        contentByte[23] = (byte)0x00;





        //校验码
        contentByte[24]= DataUtils.HexToByte(getBCC(contentByte));
        return contentByte;
    }

}
